home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 1.iso / HENSA / MATHS / PLPLOT / PLPLOT.ZIP / src / stubc / sccont.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-23  |  10.3 KB  |  422 lines
  1. /* $Id: sccont.c,v 1.3 1994/03/23 08:38:37 mjl Exp $
  2.  * $Log: sccont.c,v $
  3.  * Revision 1.3  1994/03/23  08:38:37  mjl
  4.  * Name change for contour plotter base routine; lots of new plfshade
  5.  * front-end functions added.
  6.  *
  7.  * Revision 1.2  1993/10/21  19:27:06  mjl
  8.  * Changed all names that ended with an underscore (as part of the C/Fortran
  9.  * linkage) to end with a '7' instead, to avoid problems with f2c.
  10.  *
  11.  * Revision 1.1  1993/01/23  06:04:17  mjl
  12.  * New front-end for contours from fortran.  Does amazingly little work now,
  13.  * just defines an appropriate function evaluator and coordinate transformers
  14.  * and calls the main contour function.
  15. */
  16.  
  17. /*    sccont.c
  18.  
  19.     Contour plotter front-ends for Fortran.
  20. */
  21.  
  22. #include "plstubs.h"
  23.  
  24. /*----------------------------------------------------------------------*\
  25. * pltr0f()
  26. *
  27. * Identity transformation for plots from Fortran.
  28. * Only difference from C-language identity function (pltr0) is that the
  29. * Fortran paradigm for array index is used, i.e. starting at 1.
  30. \*----------------------------------------------------------------------*/
  31.  
  32. void
  33. pltr0f(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
  34. {
  35.     *tx = x + 1.0;
  36.     *ty = y + 1.0;
  37. }
  38.  
  39. /*----------------------------------------------------------------------*\
  40. * pltr2f()
  41. *
  42. * Does linear interpolation from doubly dimensioned coord arrays
  43. * (row dominant, i.e. Fortran ordering).
  44. *
  45. * This routine includes lots of checks for out of bounds.  This would
  46. * occur occasionally due to a bug in the contour plotter that is now fixed.
  47. * If an out of bounds coordinate is obtained, the boundary value is provided
  48. * along with a warning.  These checks should stay since no harm is done if
  49. * if everything works correctly.
  50. \*----------------------------------------------------------------------*/
  51.  
  52. void
  53. pltr2f(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
  54. {
  55.     PLINT ul, ur, vl, vr;
  56.     PLFLT du, dv;
  57.     PLFLT xll, xlr, xrl, xrr;
  58.     PLFLT yll, ylr, yrl, yrr;
  59.     PLFLT xmin, xmax, ymin, ymax;
  60.  
  61.     PLcGrid *cgrid = (PLcGrid *) pltr_data;
  62.     PLFLT *xg = cgrid->xg;
  63.     PLFLT *yg = cgrid->yg;
  64.     PLINT nx = cgrid->nx;
  65.     PLINT ny = cgrid->ny;
  66.  
  67.     ul = (PLINT) x;
  68.     ur = ul + 1;
  69.     du = x - ul;
  70.  
  71.     vl = (PLINT) y;
  72.     vr = vl + 1;
  73.     dv = y - vl;
  74.  
  75.     xmin = 0;
  76.     xmax = nx - 1;
  77.     ymin = 0;
  78.     ymax = ny - 1;
  79.  
  80.     if (x < xmin || x > xmax || y < ymin || y > ymax) {
  81.     plwarn("pltr2f: Invalid coordinates");
  82.  
  83.     if (x < xmin) {
  84.  
  85.         if (y < ymin) {
  86.         *tx = *xg;
  87.         *ty = *yg;
  88.         }
  89.         else if (y > ymax) {
  90.         *tx = *(xg + (ny - 1) * nx);
  91.         *ty = *(yg + (ny - 1) * nx);
  92.         }
  93.         else {
  94.         ul = 0;
  95.         xll = *(xg + ul + vl * nx);
  96.         yll = *(yg + ul + vl * nx);
  97.         xlr = *(xg + ul + vr * nx);
  98.         ylr = *(yg + ul + vr * nx);
  99.  
  100.         *tx = xll * (1 - dv) + xlr * (dv);
  101.         *ty = yll * (1 - dv) + ylr * (dv);
  102.         }
  103.     }
  104.     else if (x > xmax) {
  105.  
  106.         if (y < ymin) {
  107.         *tx = *(xg + (nx - 1));
  108.         *ty = *(yg + (nx - 1));
  109.         }
  110.         else if (y > ymax) {
  111.         *tx = *(xg + (nx - 1) + (ny - 1) * nx);
  112.         *ty = *(yg + (nx - 1) + (ny - 1) * nx);
  113.         }
  114.         else {
  115.         ul = nx - 1;
  116.         xll = *(xg + ul + vl * nx);
  117.         yll = *(yg + ul + vl * nx);
  118.         xlr = *(xg + ul + vr * nx);
  119.         ylr = *(yg + ul + vr * nx);
  120.  
  121.         *tx = xll * (1 - dv) + xlr * (dv);
  122.         *ty = yll * (1 - dv) + ylr * (dv);
  123.         }
  124.     }
  125.     else {
  126.         if (y < ymin) {
  127.         vl = 0;
  128.         xll = *(xg + ul + vl * nx);
  129.         xrl = *(xg + ur + vl * nx);
  130.         yll = *(yg + ul + vl * nx);
  131.         yrl = *(yg + ur + vl * nx);
  132.  
  133.         *tx = xll * (1 - du) + xrl * (du);
  134.         *ty = yll * (1 - du) + yrl * (du);
  135.         }
  136.         else if (y > ymax) {
  137.         vr = ny - 1;
  138.         xlr = *(xg + ul + vr * nx);
  139.         xrr = *(xg + ur + vr * nx);
  140.         ylr = *(yg + ul + vr * nx);
  141.         yrr = *(yg + ur + vr * nx);
  142.  
  143.         *tx = xlr * (1 - du) + xrr * (du);
  144.         *ty = ylr * (1 - du) + yrr * (du);
  145.         }
  146.     }
  147.     }
  148.  
  149. /* Normal case.
  150.    Look up coordinates in row-dominant array.
  151.    Have to handle right boundary specially -- if at the edge, we'd
  152.    better not reference the out of bounds point. */
  153.  
  154.     else {
  155.  
  156.     xll = *(xg + ul + vl * nx);
  157.     yll = *(yg + ul + vl * nx);
  158.  
  159. /* ur is out of bounds */
  160.  
  161.     if (ur == nx && vr < ny) {
  162.  
  163.         xlr = *(xg + ul + vr * nx);
  164.         ylr = *(yg + ul + vr * nx);
  165.  
  166.         *tx = xll * (1 - dv) + xlr * (dv);
  167.         *ty = yll * (1 - dv) + ylr * (dv);
  168.     }
  169.  
  170. /* vr is out of bounds */
  171.  
  172.     else if (ur < nx && vr == ny) {
  173.  
  174.         xrl = *(xg + ur + vl * nx);
  175.         yrl = *(yg + ur + vl * nx);
  176.  
  177.         *tx = xll * (1 - du) + xrl * (du);
  178.         *ty = yll * (1 - du) + yrl * (du);
  179.     }
  180.  
  181. /* both ur and vr are out of bounds */
  182.  
  183.     else if (ur == nx && vr == ny) {
  184.  
  185.         *tx = xll;
  186.         *ty = yll;
  187.     }
  188.  
  189. /* everything in bounds */
  190.  
  191.     else {
  192.  
  193.         xrl = *(xg + ur + vl * nx);
  194.         xlr = *(xg + ul + vr * nx);
  195.         xrr = *(xg + ur + vr * nx);
  196.  
  197.         yrl = *(yg + ur + vl * nx);
  198.         ylr = *(yg + ul + vr * nx);
  199.         yrr = *(yg + ur + vr * nx);
  200. /* INDENT OFF */
  201.         *tx = xll * (1 - du) * (1 - dv) + xlr * (1 - du) * (dv) +
  202.           xrl *   (du)   * (1 - dv) + xrr *   (du)   * (dv);
  203.  
  204.         *ty = yll * (1 - du) * (1 - dv) + ylr * (1 - du) * (dv) +
  205.           yrl *   (du)   * (1 - dv) + yrr *   (du)   * (dv);
  206. /* INDENT ON */
  207.     }
  208.     }
  209. }
  210.  
  211. /*----------------------------------------------------------------------*\
  212. * Contour plotter front-ends.
  213. * These specify the row-dominant function evaluator in the plfcont
  214. * argument list.  NO TRANSPOSE IS NECESSARY.  The routines are as follows:
  215. *
  216. * - plcon0    no transformation
  217. * - plcon1    linear interpolation from singly dimensioned coord arrays
  218. * - plcon2    linear interpolation from doubly dimensioned coord arrays
  219. *
  220. * The latter two work by calling plfcont() with the appropriate grid
  221. * structure for input to pltr2f().
  222. \*----------------------------------------------------------------------*/
  223.  
  224. /* no transformation */
  225.  
  226. void
  227. PLCON07(PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
  228.     PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel)
  229. {
  230.     PLfGrid fgrid;
  231.  
  232.     fgrid.nx = *nx;
  233.     fgrid.ny = *ny;
  234.     fgrid.f = z;
  235.  
  236.     plfcont(plf2evalr, (void *) &fgrid,
  237.         *nx, *ny, *kx, *lx, *ky, *ly, clevel, *nlevel,
  238.         pltr0f, NULL);
  239. }
  240.  
  241. /* 1-d transformation */
  242.  
  243. void
  244. PLCON17(PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
  245.     PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel,
  246.     PLFLT *xg, PLFLT *yg)
  247. {
  248.     PLfGrid fgrid;
  249.     PLcGrid cgrid;
  250.  
  251.     fgrid.nx = *nx;
  252.     fgrid.ny = *ny;
  253.     fgrid.f = z;
  254.  
  255.     cgrid.nx = *nx;
  256.     cgrid.ny = *ny;
  257.     cgrid.xg = xg;
  258.     cgrid.yg = yg;
  259.  
  260.     plfcont(plf2evalr, (void *) &fgrid,
  261.         *nx, *ny, *kx, *lx, *ky, *ly, clevel, *nlevel,
  262.         pltr1, (void *) &cgrid);
  263. }
  264.  
  265. /* 2-d transformation */
  266.  
  267. void
  268. PLCON27(PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
  269.     PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel,
  270.     PLFLT *xg, PLFLT *yg)
  271. {
  272.     PLfGrid fgrid;
  273.     PLcGrid cgrid;
  274.  
  275.     fgrid.nx = *nx;
  276.     fgrid.ny = *ny;
  277.     fgrid.f = z;
  278.  
  279.     cgrid.nx = *nx;
  280.     cgrid.ny = *ny;
  281.     cgrid.xg = xg;
  282.     cgrid.yg = yg;
  283.  
  284.     plfcont(plf2evalr, (void *) &fgrid,
  285.         *nx, *ny, *kx, *lx, *ky, *ly, clevel, *nlevel,
  286.         pltr2f, (void *) &cgrid);
  287. }
  288.  
  289. /*----------------------------------------------------------------------*\
  290. * Here are the old contour plotters.
  291. \*----------------------------------------------------------------------*/
  292.  
  293. static void
  294. pltr(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
  295. {
  296.     PLFLT *tr = (PLFLT *) pltr_data;
  297.  
  298.     *tx = tr[0] * x + tr[1] * y + tr[2];
  299.     *ty = tr[3] * x + tr[4] * y + tr[5];
  300. }
  301.  
  302. void
  303. PLCONT7(PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
  304.     PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel, PLFLT *ftr)
  305. {
  306.     PLfGrid fgrid;
  307.  
  308.     fgrid.nx = *nx;
  309.     fgrid.ny = *ny;
  310.     fgrid.f = z;
  311.  
  312.     plfcont(plf2evalr, (void *) &fgrid,
  313.         *nx, *ny, *kx, *lx, *ky, *ly, clevel, *nlevel,
  314.         pltr, (void *) ftr);
  315. }
  316.  
  317. /*----------------------------------------------------------------------*\
  318. * plfshade front-ends.
  319. * These specify the row-dominant function evaluator in the plfshade
  320. * argument list.  NO TRANSPOSE IS NECESSARY.  The routines are as follows:
  321. *
  322. * - plshade0    no transformation
  323. * - plshade1    linear interpolation from singly dimensioned coord arrays
  324. * - plshade2    linear interpolation from doubly dimensioned coord arrays
  325. *
  326. * The latter two work by calling plfshade() with the appropriate grid
  327. * structure for input to pltr2f().
  328. \*----------------------------------------------------------------------*/
  329.  
  330. void
  331. PLSHADE07(PLFLT *z, PLINT *nx, PLINT *ny, char *defined,
  332.       PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
  333.       PLFLT *shade_min, PLFLT *shade_max,
  334.       PLINT *sh_cmap, PLFLT *sh_color, PLINT *sh_width,
  335.       PLINT *min_color, PLINT *min_width,
  336.       PLINT *max_color, PLINT *max_width)
  337. {
  338.     PLfGrid fgrid;
  339.     PLINT rect = 1;
  340.  
  341.     fgrid.nx = *nx;
  342.     fgrid.ny = *ny;
  343.     fgrid.f = z;
  344.  
  345.     plfshade(plf2evalr, (PLPointer) &fgrid,
  346.          NULL, NULL,
  347.          *nx, *ny,
  348.          *xmin, *xmax, *ymin, *ymax,
  349.          *shade_min, *shade_max,
  350.          *sh_cmap, *sh_color, *sh_width,
  351.          *min_color, *min_width, *max_color, *max_width,
  352.          c_plfill, rect, NULL, NULL);
  353. }
  354.  
  355. /* 1-d transformation */
  356.  
  357. void
  358. PLSHADE17(PLFLT *z, PLINT *nx, PLINT *ny, char *defined,
  359.       PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
  360.       PLFLT *shade_min, PLFLT *shade_max,
  361.       PLINT *sh_cmap, PLFLT *sh_color, PLINT *sh_width,
  362.       PLINT *min_color, PLINT *min_width,
  363.       PLINT *max_color, PLINT *max_width,
  364.       PLFLT *xg, PLFLT *yg)
  365. {
  366.     PLfGrid fgrid;
  367.     PLcGrid cgrid;
  368.     PLINT rect = 1;
  369.  
  370.     fgrid.nx = *nx;
  371.     fgrid.ny = *ny;
  372.     fgrid.f = z;
  373.  
  374.     cgrid.nx = *nx;
  375.     cgrid.ny = *ny;
  376.     cgrid.xg = xg;
  377.     cgrid.yg = yg;
  378.  
  379.     plfshade(plf2evalr, (PLPointer) &fgrid,
  380.          NULL, NULL,
  381.          *nx, *ny,
  382.          *xmin, *xmax, *ymin, *ymax,
  383.          *shade_min, *shade_max,
  384.          *sh_cmap, *sh_color, *sh_width,
  385.          *min_color, *min_width, *max_color, *max_width,
  386.          c_plfill, rect, pltr1, (PLPointer) &cgrid);
  387. }
  388.  
  389. /* 2-d transformation */
  390.  
  391. void
  392. PLSHADE27(PLFLT *z, PLINT *nx, PLINT *ny, char *defined,
  393.       PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
  394.       PLFLT *shade_min, PLFLT *shade_max,
  395.       PLINT *sh_cmap, PLFLT *sh_color, PLINT *sh_width,
  396.       PLINT *min_color, PLINT *min_width,
  397.       PLINT *max_color, PLINT *max_width,
  398.       PLFLT *xg, PLFLT *yg)
  399. {
  400.     PLfGrid fgrid;
  401.     PLcGrid cgrid;
  402.     PLINT rect = 0;
  403.  
  404.     fgrid.nx = *nx;
  405.     fgrid.ny = *ny;
  406.     fgrid.f = z;
  407.  
  408.     cgrid.nx = *nx;
  409.     cgrid.ny = *ny;
  410.     cgrid.xg = xg;
  411.     cgrid.yg = yg;
  412.  
  413.     plfshade(plf2evalr, (PLPointer) &fgrid,
  414.          NULL, NULL,
  415.          *nx, *ny,
  416.          *xmin, *xmax, *ymin, *ymax,
  417.          *shade_min, *shade_max,
  418.          *sh_cmap, *sh_color, *sh_width,
  419.          *min_color, *min_width, *max_color, *max_width,
  420.          c_plfill, rect, pltr2f, (PLPointer) &cgrid);
  421. }
  422.